/**
 * 拓扑排序
 *
 * 描述
 * 给定一个包含n个点m条边的有向无环图，求出该图的拓扑序。若图的拓扑序不唯一，
 * 输出任意合法的拓扑序即可。若该图不能拓扑排序，输出−1。
 *
 * 输入描述：
 * 第一行输入两个整数
 * n,m (1≤n,m≤2⋅10^5)，表示点的个数和边的条数。
 * 接下来的m行，每行输入两个整数ui,vi(1≤u,v≤n)，
 * 表示ui到vi之间有一条有向边。
 *
 * 输出描述：
 * 若图存在拓扑序，输出一行
 * n个整数，表示拓扑序。否则输出−1。
 *
 * 注意：输出的最后一个数后面不要带空格。
 */

import java.io.*;
import java.util.*;

/**
 * 这咯我们需要知道什么是拓扑排序, 拓扑排序是图中判断图是否有环的, 要是没有环, 那么一定可以遍历
 * 完, 要是有环就会遍历不完, 简单来说, 就是每个顶点的度和关联边, 要是这个顶点被一条边关联, 那么
 * 它的度就加 1, 所以我们先将度为 0 的点加入队列, 不断的出边, 减少顶点的度数, 度为0 就在加入
 * 队列, 直到遍历到队列为空, 无环的图就会正常结束, 但是有环的是遍历不完的
 * 时间复杂度 : O(n + m)
 * 空间复杂度 : O(n + m)
 */

public class Main {

    public static PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
    public static Read in = new Read();

    public static void main(String[] args) throws IOException {

        int n = in.nextInt(), m = in.nextInt();

        Map<Integer, List<Integer>> edges = new HashMap<>();

        int[] cnt = new int[n + 1];

        for (int i = 0; i < m; i++) {

            int a = in.nextInt(), b = in.nextInt();

            // 统计入度
            cnt[b]++;
            if (!edges.containsKey(a)) {

                // 这里要初始化list, 不然会报 null 异常
                edges.put(a, new ArrayList<>());
            }

            // 关联边
            edges.get(a).add(b);
        }

        Queue<Integer> queue = new LinkedList<>();

        // 添加度为 0 的点
        for (int i = 1; i <= n; i++) {
            if (cnt[i] == 0) {
                queue.add(i);
            }
        }

        // 记录结果
        int[] res = new int[n];
        int pos = 0;

        while (!queue.isEmpty()) {

            int x = queue.poll();

            // 记录拓扑排序
            res[pos++] = x;

            // 遍历他的关联边
            for (int i : edges.getOrDefault(x, new ArrayList<>())) {

                // 这里没有度为 0 的, 度为 0 之前就已经加入了
                // 度减 1
                cnt[i]--;
                if (cnt[i] == 0) {
                    queue.add(i);
                }
            }
        }

        // 这里判断 pos 是否到达了 最后的位置
        if (pos == n) {

            // 最后一个位置不需要 " "
            for (int i = 0; i < pos - 1; i++) {
                out.print(res[i] + " ");
            }

            out.println(res[pos - 1]);
        } else {

            out.println(-1);
        }

        out.close();
    }
}

// 自定义快速读入
class Read {
    StringTokenizer st = new StringTokenizer("");
    BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    String next() throws IOException {
        while(!st.hasMoreTokens()) {
            st = new StringTokenizer(bf.readLine());
        }
        return st.nextToken();
    }

    String nextLine() throws IOException {
        return bf.readLine();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
}